home *** CD-ROM | disk | FTP | other *** search
/ Amiga Games Extra 1996 September / Amiga Games Extra CD-ROM 9-1996.iso / archive / spiele / publicdomain / elan.lha / elan / src / files.c < prev    next >
C/C++ Source or Header  |  1996-06-07  |  7KB  |  313 lines
  1.  
  2. #include "global.h"
  3. #include "coredefs.h"
  4. #include "texts.h"
  5. #include "symbols.h"
  6. #include "elan.h"
  7. #include "interf.h"
  8. #include "system.h"
  9. #include "files.h"
  10.  
  11. const char internal_header[HEADER_LEN] = HEADER_TAG;
  12. char file_header[HEADER_LEN];
  13.  
  14. void save_game()
  15.     {
  16.     if(save_state() != ok)
  17.         display_message(save_error);
  18.     else
  19.         display_message(game_saved);
  20.     }
  21.  
  22. void load_game()
  23.     {
  24.     if(load_state() != ok)
  25.         display_message(load_error);
  26.     else
  27.         {
  28.         if(strcmp(internal_header, file_header))
  29.             display_message(file_mismatch);
  30.         else
  31.             display_message(game_loaded);
  32.         }
  33.  
  34.     display_map();
  35.     if(ifc.mode != start_mode)
  36.         display_frame();
  37.     }
  38.  
  39. error_class save_state()
  40.     {
  41.     FILE *fp;
  42.     device *plant;
  43.     channel *duct;
  44.     mobile *turtle;
  45.     cell *loc;
  46.     int p, d, g, t;
  47.  
  48.     fp = fopen(SAVEFILE_NAME, "wb");
  49.     if(!fp)
  50.         return write_file_err;
  51.  
  52.     fwrite(internal_header, HEADER_LEN, 1, fp);
  53.     fwrite(&env, sizeof(env), 1, fp);
  54.     fwrite(&sys, sizeof(sys), 1, fp);
  55.     fwrite(&usr, sizeof(usr), 1, fp);
  56.     fwrite(&ifc, sizeof(ifc), 1, fp);
  57.  
  58.     for(p = 0; p < sys.tot_plants; p++)
  59.         {
  60.         plant = sys.plant[p];
  61.         fwrite(plant, sizeof(*plant), 1, fp);
  62.         write_cell_ref(plant->loc, fp);
  63.         }
  64.  
  65.     for(d = 0; d < sys.tot_ducts; d++)
  66.         {
  67.         duct = sys.duct[d];
  68.         fwrite(duct, sizeof(*duct), 1, fp);
  69.         write_cell_ref(duct->start_loc, fp);
  70.         write_cell_ref(duct->end_loc, fp);
  71.         write_cell_ref(duct->break_loc, fp);
  72.         for(p = 0; p < MAX_PROVIDERS_NUMBER; p++)
  73.             {
  74.             write_device_ref(duct->provider[p], fp);
  75.             if(!duct->provider[p])
  76.                 break;
  77.             }
  78.         }
  79.  
  80.     for(p = 0; p < sys.tot_plants; p++)
  81.         for(g = 0; g < PRIMARY_RT_NUMBER; g++)
  82.             write_channel_ref(sys.plant[p]->input[g], fp);
  83.  
  84.     for(t = 0; t < sys.tot_turtles; t++)
  85.         {
  86.         turtle = sys.turtle[t];
  87.         if(turtle)
  88.             {
  89.             fwrite(turtle, sizeof(*turtle), 1, fp);
  90.             write_cell_ref(turtle->loc, fp);
  91.             }
  92.         }
  93.  
  94.     for(loc = &env.map[0][0]; loc <= &env.map[MAP_ROWS - 1][MAP_COLS - 1]; loc++)
  95.         {
  96.         write_channel_ref(loc->alfa_duct, fp);
  97.         write_channel_ref(loc->beta_duct, fp);
  98.         write_cell_ref(loc->alfa_flow, fp);
  99.         write_cell_ref(loc->beta_flow, fp);
  100.         write_cell_ref(loc->break_flow, fp);
  101.         }
  102.  
  103.     write_cell_ref(ifc.cursor, fp);
  104.  
  105.     fclose(fp);
  106.  
  107.     return ok;
  108.     }
  109.  
  110. error_class load_state()
  111.     {
  112.     FILE *fp;
  113.     device *plant;
  114.     channel *duct;
  115.     mobile *turtle;
  116.     cell *loc;
  117.     int p, d, g, t;
  118.  
  119.     fp = fopen(SAVEFILE_NAME, "rb");
  120.     if(!fp)
  121.         return read_file_err;
  122.  
  123.     for(p = 0; p < sys.tot_plants; p++)
  124.         free(sys.plant[p]);
  125.  
  126.     for(d = 0; d < sys.tot_ducts; d++)
  127.         free(sys.duct[d]);
  128.  
  129.     for(t = 0; t < sys.tot_turtles; t++)
  130.         free(sys.turtle[t]);
  131.  
  132.     fread(file_header, HEADER_LEN, 1, fp);
  133.     fread(&env, sizeof(env), 1, fp);
  134.     fread(&sys, sizeof(sys), 1, fp);
  135.     fread(&usr, sizeof(usr), 1, fp);
  136.     fread(&ifc, sizeof(ifc), 1, fp);
  137.  
  138.     for(p = 0; p < sys.tot_plants; p++)
  139.         {
  140.         plant = calloc(1, sizeof(*plant));
  141.         assert(plant != NULL);
  142.         sys.plant[p] = plant;
  143.         fread(plant, sizeof(*plant), 1, fp);
  144.         loc = read_cell_ref(fp);
  145.         plant->loc = loc;
  146.         loc->plant = plant;
  147.         }
  148.  
  149.     for(d = 0; d < sys.tot_ducts; d++)
  150.         {
  151.         duct = calloc(1, sizeof(*duct));
  152.         assert(duct != NULL);
  153.         sys.duct[d] = duct;
  154.         fread(duct, sizeof(*duct), 1, fp);
  155.         duct->start_loc = read_cell_ref(fp);
  156.         duct->end_loc = read_cell_ref(fp);
  157.         duct->break_loc = read_cell_ref(fp);
  158.         for(p = 0; p < MAX_PROVIDERS_NUMBER; p++)
  159.             {
  160.             duct->provider[p] = read_device_ref(fp);
  161.             if(!duct->provider[p])
  162.                 break;
  163.             }
  164.         }
  165.  
  166.     for(p = 0; p < sys.tot_plants; p++)
  167.         for(g = 0; g < PRIMARY_RT_NUMBER; g++)
  168.             sys.plant[p]->input[g] = read_channel_ref(fp);
  169.  
  170.     for(t = 0; t < sys.tot_turtles; t++)
  171.         {
  172.         if(sys.turtle[t])
  173.             {
  174.             turtle = calloc(1, sizeof(*turtle));
  175.             assert(turtle != NULL);
  176.             sys.turtle[t] = turtle;
  177.             fread(turtle, sizeof(*turtle), 1, fp);
  178.             loc = read_cell_ref(fp);
  179.             turtle->loc = loc;
  180.             loc->turtle = turtle;
  181.             }
  182.         }
  183.  
  184.     for(loc = &env.map[0][0]; loc <= &env.map[MAP_ROWS - 1][MAP_COLS - 1]; loc++)
  185.         {
  186.         loc->alfa_duct = read_channel_ref(fp);
  187.         loc->beta_duct = read_channel_ref(fp);
  188.         loc->alfa_flow = read_cell_ref(fp);
  189.         loc->beta_flow = read_cell_ref(fp);
  190.         loc->break_flow = read_cell_ref(fp);
  191.         }
  192.  
  193.     ifc.cursor = read_cell_ref(fp);
  194.  
  195.     fclose(fp);
  196.  
  197.     return ok;
  198.     }
  199.  
  200. size_t write_device_ref(device *plant, FILE *fp)
  201.     {
  202.     int p;
  203.  
  204.     if(plant)
  205.         for(p = 0; sys.plant[p] != plant; p++);
  206.     else
  207.         p = NULL_REF;
  208.  
  209.     return fwrite(&p, sizeof(p), 1, fp);
  210.     }
  211.  
  212. device *read_device_ref(FILE *fp)
  213.     {
  214.     int p;
  215.  
  216.     fread(&p, sizeof(p), 1, fp);
  217.     if(p != NULL_REF)
  218.         return sys.plant[p];
  219.     else
  220.         return NULL;
  221.     }
  222.  
  223. size_t write_channel_ref(channel *duct, FILE *fp)
  224.     {
  225.     int d;
  226.  
  227.     if(duct)
  228.         for(d = 0; sys.duct[d] != duct; d++);
  229.     else
  230.         d = NULL_REF;
  231.  
  232.     return fwrite(&d, sizeof(d), 1, fp);
  233.     }
  234.  
  235. channel *read_channel_ref(FILE *fp)
  236.     {
  237.     int d;
  238.  
  239.     fread(&d, sizeof(d), 1, fp);
  240.     if(d != NULL_REF)
  241.         return sys.duct[d];
  242.     else
  243.         return NULL;
  244.     }
  245.  
  246. size_t write_mobile_ref(mobile *turtle, FILE *fp)
  247.     {
  248.     int t;
  249.  
  250.     if(turtle)
  251.         for(t = 0; sys.turtle[t] != turtle; t++);
  252.     else
  253.         t = NULL_REF;
  254.  
  255.     return fwrite(&t, sizeof(t), 1, fp);
  256.     }
  257.  
  258. mobile *read_mobile_ref(FILE *fp)
  259.     {
  260.     int t;
  261.  
  262.     fread(&t, sizeof(t), 1, fp);
  263.     if(t != NULL_REF)
  264.         return sys.turtle[t];
  265.     else
  266.         return NULL;
  267.     }
  268.  
  269. size_t write_cell_ref(cell *loc, FILE *fp)
  270.     {
  271.     position pos;
  272.  
  273.     if(loc)
  274.         pos = loc->pos;
  275.     else
  276.         pos.i = NULL_REF;
  277.  
  278.     return fwrite(&pos, sizeof(pos), 1, fp);
  279.     }
  280.  
  281. cell *read_cell_ref(FILE *fp)
  282.     {
  283.     position pos;
  284.  
  285.     fread(&pos, sizeof(pos), 1, fp);
  286.     if(pos.i != NULL_REF)
  287.         return &env.map[pos.i][pos.j];
  288.     else
  289.         return NULL;
  290.     }
  291.  
  292. error_class dump_map()
  293.     {
  294.     FILE *fp;
  295.     int i, j;
  296.  
  297.     fp = fopen(DUMPFILE_NAME, "w");
  298.     if(!fp)
  299.         return write_file_err;
  300.  
  301.     for(i = 0; i < MAP_ROWS; i++)
  302.         {
  303.         for(j = 0; j < MAP_COLS; j++)
  304.             fputc(env.map[i][j].sym.icon, fp);
  305.         fputc('\n', fp);
  306.         }
  307.  
  308.     fclose(fp);
  309.  
  310.     return ok;
  311.     }
  312.  
  313.